{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Configurations for Colab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "IN_COLAB = \"google.colab\" in sys.modules\n",
    "\n",
    "if IN_COLAB:\n",
    "    !apt install python-opengl\n",
    "    !apt install ffmpeg\n",
    "    !apt install xvfb\n",
    "    !pip install PyVirtualDisplay==3.0\n",
    "    !pip install gymnasium==0.28.1\n",
    "    from pyvirtualdisplay import Display\n",
    "    \n",
    "    # Start virtual display\n",
    "    dis = Display(visible=0, size=(400, 400))\n",
    "    dis.start()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 03. Prioritized Experience Replay (PER)\n",
    "\n",
    "[T. Schaul et al., \"Prioritized Experience Replay.\" arXiv preprint arXiv:1511.05952, 2015.](https://arxiv.org/pdf/1511.05952.pdf)\n",
    "\n",
    "Using a replay memory leads to design choices at two levels: which experiences to store, and which experiences to replay (and how to do so). This paper addresses only the latter: making the most effective use of the replay memory for learning, assuming that its contents are outside of our control.\n",
    "\n",
    "The central component of prioritized replay is the criterion by which the importance of each transition is measured. A reasonable approach is to use the magnitude of a transition’s TD error $\\delta$, which indicates how ‘surprising’\n",
    "or unexpected the transition is. This algorithm stores the last encountered TD error along with each transition in the replay memory. The transition with the largest absolute TD error is replayed from the memory. A Q-learning update\n",
    "is applied to this transition, which updates the weights in proportion to the TD error. One thing to note that new transitions arrive without a known TD-error, so it puts them at maximal priority in order to guarantee that all experience is seen at least once. (see *store* method)\n",
    "\n",
    "We might use 2 ideas to deal with TD-error: 1. greedy TD-error prioritization, 2. stochastic prioritization. However, greedy TD-error prioritization has a severe drawback. Greedy prioritization focuses on a small subset of the experience: errors shrink slowly, especially when using function approximation, meaning that the initially high error transitions get replayed frequently. This lack of diversity that makes the system prone to over-fitting. To overcome this issue, we will use a stochastic sampling method that interpolates between pure greedy prioritization and uniform random sampling.\n",
    "\n",
    "$$\n",
    "P(i) = \\frac{p_i^{\\alpha}}{\\sum_k p_k^{\\alpha}}\n",
    "$$\n",
    "\n",
    "where $p_i > 0$ is the priority of transition $i$. The exponent $\\alpha$ determines how much prioritization is used, with $\\alpha = 0$ corresponding to the uniform case. In practice, we use additional term $\\epsilon$ in order to guarantee all transactions can be possibly sampled: $p_i = |\\delta_i| + \\epsilon$, where $\\epsilon$ is a small positive constant.\n",
    "\n",
    "One more. Let's recall one of the main ideas of DQN. To remove correlation of observations, it uses uniformly random sampling from the replay buffer. Prioritized replay introduces bias because it doesn't sample experiences uniformly at random due to the sampling proportion correspoding to TD-error. We can correct this bias by using importance-sampling (IS) weights\n",
    "\n",
    "$$\n",
    "w_i = \\big( \\frac{1}{N} \\cdot \\frac{1}{P(i)} \\big)^\\beta\n",
    "$$\n",
    "\n",
    "that fully compensates for the non-uniform probabilities $P(i)$ if $\\beta = 1$. These weights can be folded into the Q-learning update by using $w_i\\delta_i$ instead of $\\delta_i$. In typical reinforcement learning scenarios, the unbiased nature of the updates is most important near convergence at the end of training, We therefore exploit the flexibility of annealing the amount of importance-sampling correction over time, by defining a schedule on the exponent $\\beta$ that reaches 1 only at the end of learning. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import random\n",
    "from typing import Dict, List, Tuple\n",
    "\n",
    "import gymnasium as gym\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from IPython.display import clear_output\n",
    "\n",
    "if IN_COLAB and not os.path.exists(\"segment_tree.py\"):\n",
    "    # download segment tree module\n",
    "    !wget https://raw.githubusercontent.com/curt-park/rainbow-is-all-you-need/master/segment_tree.py\n",
    "    \n",
    "from segment_tree import MinSegmentTree, SumSegmentTree"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Replay buffer\n",
    "\n",
    "Please see *01.dqn.ipynb* for detailed description."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    \"\"\"A simple numpy replay buffer.\"\"\"\n",
    "\n",
    "    def __init__(self, obs_dim: int, size: int, batch_size: int = 32):\n",
    "        self.obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.next_obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.acts_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.rews_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.done_buf = np.zeros(size, dtype=np.float32)\n",
    "        self.max_size, self.batch_size = size, batch_size\n",
    "        self.ptr, self.size, = 0, 0\n",
    "\n",
    "    def store(\n",
    "        self,\n",
    "        obs: np.ndarray,\n",
    "        act: np.ndarray, \n",
    "        rew: float, \n",
    "        next_obs: np.ndarray, \n",
    "        done: bool,\n",
    "    ):\n",
    "        self.obs_buf[self.ptr] = obs\n",
    "        self.next_obs_buf[self.ptr] = next_obs\n",
    "        self.acts_buf[self.ptr] = act\n",
    "        self.rews_buf[self.ptr] = rew\n",
    "        self.done_buf[self.ptr] = done\n",
    "        self.ptr = (self.ptr + 1) % self.max_size\n",
    "        self.size = min(self.size + 1, self.max_size)\n",
    "\n",
    "    def sample_batch(self) -> Dict[str, np.ndarray]:\n",
    "        idxs = np.random.choice(self.size, size=self.batch_size, replace=False)\n",
    "        return dict(obs=self.obs_buf[idxs],\n",
    "                    next_obs=self.next_obs_buf[idxs],\n",
    "                    acts=self.acts_buf[idxs],\n",
    "                    rews=self.rews_buf[idxs],\n",
    "                    done=self.done_buf[idxs])\n",
    "\n",
    "    def __len__(self) -> int:\n",
    "        return self.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prioritized replay Buffer\n",
    "\n",
    "The key concept of PER's implementation is *Segment Tree*. It efficiently stores and samples transitions while managing the priorities of them. We recommend you understand how it works before you move on. Here are references for you:\n",
    "\n",
    "- In Korean: https://mrsyee.github.io/rl/2019/01/25/PER-sumtree/\n",
    "- In English: https://www.geeksforgeeks.org/segment-tree-set-1-sum-of-given-range/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class PrioritizedReplayBuffer(ReplayBuffer):\n",
    "    \"\"\"Prioritized Replay buffer.\n",
    "    \n",
    "    Attributes:\n",
    "        max_priority (float): max priority\n",
    "        tree_ptr (int): next index of tree\n",
    "        alpha (float): alpha parameter for prioritized replay buffer\n",
    "        sum_tree (SumSegmentTree): sum tree for prior\n",
    "        min_tree (MinSegmentTree): min tree for min prior to get max weight\n",
    "        \n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(\n",
    "        self, \n",
    "        obs_dim: int,\n",
    "        size: int, \n",
    "        batch_size: int = 32, \n",
    "        alpha: float = 0.6\n",
    "    ):\n",
    "        \"\"\"Initialization.\"\"\"\n",
    "        assert alpha >= 0\n",
    "        \n",
    "        super(PrioritizedReplayBuffer, self).__init__(obs_dim, size, batch_size)\n",
    "        self.max_priority, self.tree_ptr = 1.0, 0\n",
    "        self.alpha = alpha\n",
    "        \n",
    "        # capacity must be positive and a power of 2.\n",
    "        tree_capacity = 1\n",
    "        while tree_capacity < self.max_size:\n",
    "            tree_capacity *= 2\n",
    "\n",
    "        self.sum_tree = SumSegmentTree(tree_capacity)\n",
    "        self.min_tree = MinSegmentTree(tree_capacity)\n",
    "        \n",
    "    def store(\n",
    "        self, \n",
    "        obs: np.ndarray, \n",
    "        act: int, \n",
    "        rew: float, \n",
    "        next_obs: np.ndarray, \n",
    "        done: bool\n",
    "    ):\n",
    "        \"\"\"Store experience and priority.\"\"\"\n",
    "        super().store(obs, act, rew, next_obs, done)\n",
    "        \n",
    "        self.sum_tree[self.tree_ptr] = self.max_priority ** self.alpha\n",
    "        self.min_tree[self.tree_ptr] = self.max_priority ** self.alpha\n",
    "        self.tree_ptr = (self.tree_ptr + 1) % self.max_size\n",
    "\n",
    "    def sample_batch(self, beta: float = 0.4) -> Dict[str, np.ndarray]:\n",
    "        \"\"\"Sample a batch of experiences.\"\"\"\n",
    "        assert len(self) >= self.batch_size\n",
    "        assert beta > 0\n",
    "        \n",
    "        indices = self._sample_proportional()\n",
    "        \n",
    "        obs = self.obs_buf[indices]\n",
    "        next_obs = self.next_obs_buf[indices]\n",
    "        acts = self.acts_buf[indices]\n",
    "        rews = self.rews_buf[indices]\n",
    "        done = self.done_buf[indices]\n",
    "        weights = np.array([self._calculate_weight(i, beta) for i in indices])\n",
    "        \n",
    "        return dict(\n",
    "            obs=obs,\n",
    "            next_obs=next_obs,\n",
    "            acts=acts,\n",
    "            rews=rews,\n",
    "            done=done,\n",
    "            weights=weights,\n",
    "            indices=indices,\n",
    "        )\n",
    "        \n",
    "    def update_priorities(self, indices: List[int], priorities: np.ndarray):\n",
    "        \"\"\"Update priorities of sampled transitions.\"\"\"\n",
    "        assert len(indices) == len(priorities)\n",
    "\n",
    "        for idx, priority in zip(indices, priorities):\n",
    "            assert priority > 0\n",
    "            assert 0 <= idx < len(self)\n",
    "\n",
    "            self.sum_tree[idx] = priority ** self.alpha\n",
    "            self.min_tree[idx] = priority ** self.alpha\n",
    "\n",
    "            self.max_priority = max(self.max_priority, priority)\n",
    "            \n",
    "    def _sample_proportional(self) -> List[int]:\n",
    "        \"\"\"Sample indices based on proportions.\"\"\"\n",
    "        indices = []\n",
    "        p_total = self.sum_tree.sum(0, len(self) - 1)\n",
    "        segment = p_total / self.batch_size\n",
    "        \n",
    "        for i in range(self.batch_size):\n",
    "            a = segment * i\n",
    "            b = segment * (i + 1)\n",
    "            upperbound = random.uniform(a, b)\n",
    "            idx = self.sum_tree.retrieve(upperbound)\n",
    "            indices.append(idx)\n",
    "            \n",
    "        return indices\n",
    "    \n",
    "    def _calculate_weight(self, idx: int, beta: float):\n",
    "        \"\"\"Calculate the weight of the experience at idx.\"\"\"\n",
    "        # get max weight\n",
    "        p_min = self.min_tree.min() / self.sum_tree.sum()\n",
    "        max_weight = (p_min * len(self)) ** (-beta)\n",
    "        \n",
    "        # calculate weights\n",
    "        p_sample = self.sum_tree[idx] / self.sum_tree.sum()\n",
    "        weight = (p_sample * len(self)) ** (-beta)\n",
    "        weight = weight / max_weight\n",
    "        \n",
    "        return weight"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Network\n",
    "\n",
    "We are going to use a simple network architecture with three fully connected layers and two non-linearity functions (ReLU)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Network(nn.Module):\n",
    "    def __init__(self, in_dim: int, out_dim: int):\n",
    "        \"\"\"Initialization.\"\"\"\n",
    "        super(Network, self).__init__()\n",
    "\n",
    "        self.layers = nn.Sequential(\n",
    "            nn.Linear(in_dim, 128), \n",
    "            nn.ReLU(),\n",
    "            nn.Linear(128, 128), \n",
    "            nn.ReLU(), \n",
    "            nn.Linear(128, out_dim)\n",
    "        )\n",
    "\n",
    "    def forward(self, x: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"Forward method implementation.\"\"\"\n",
    "        return self.layers(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## DQN + PER Agent\n",
    "\n",
    "Here is a summary of DQNAgent class.\n",
    "\n",
    "| Method           | Note                                                 |\n",
    "| ---              | ---                                                  |\n",
    "|select_action     | select an action from the input state.               |\n",
    "|step              | take an action and return the response of the env.   |\n",
    "|compute_dqn_loss  | return dqn loss.                                     |\n",
    "|update_model      | update the model by gradient descent.                |\n",
    "|target_hard_update| hard update from the local model to the target model.|\n",
    "|train             | train the agent during num_frames.                   |\n",
    "|test              | test the agent (1 episode).                          |\n",
    "|plot              | plot the training progresses.                        |\n",
    "\n",
    "\n",
    "All differences from pure DQN are noted with comments - PER.\n",
    "\n",
    "#### __init__\n",
    "\n",
    "Here, we use PrioritizedReplayBuffer, instead of ReplayBuffer, and use hold 2 more parameters beta and priority epsilon which are used to calculate weights and new priorities respectively.\n",
    "\n",
    "#### compute_dqn_loss & update_model\n",
    "\n",
    "It returns every loss per each sample for importance sampling before average. After updating the nework, it is necessary to update priorities of all sampled experiences.\n",
    "\n",
    "#### train\n",
    "\n",
    "beta linearly increases to 1 at every training step."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DQNAgent:\n",
    "    \"\"\"DQN Agent interacting with environment.\n",
    "    \n",
    "    Attribute:\n",
    "        env (gym.Env): openAI Gym environment\n",
    "        memory (ReplayBuffer): replay memory to store transitions\n",
    "        batch_size (int): batch size for sampling\n",
    "        epsilon (float): parameter for epsilon greedy policy\n",
    "        epsilon_decay (float): step size to decrease epsilon\n",
    "        max_epsilon (float): max value of epsilon\n",
    "        min_epsilon (float): min value of epsilon\n",
    "        target_update (int): period for target model's hard update\n",
    "        gamma (float): discount factor\n",
    "        dqn (Network): model to train and select actions\n",
    "        dqn_target (Network): target model to update\n",
    "        optimizer (torch.optim): optimizer for training dqn\n",
    "        transition (list): transition information including \n",
    "                           state, action, reward, next_state, done\n",
    "        beta (float): determines how much importance sampling is used\n",
    "        prior_eps (float): guarantees every transition can be sampled\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self, \n",
    "        env: gym.Env,\n",
    "        memory_size: int,\n",
    "        batch_size: int,\n",
    "        target_update: int,\n",
    "        epsilon_decay: float,\n",
    "        seed: int,\n",
    "        max_epsilon: float = 1.0,\n",
    "        min_epsilon: float = 0.1,\n",
    "        gamma: float = 0.99,\n",
    "        # PER parameters\n",
    "        alpha: float = 0.2,\n",
    "        beta: float = 0.6,\n",
    "        prior_eps: float = 1e-6,\n",
    "    ):\n",
    "        \"\"\"Initialization.\n",
    "        \n",
    "        Args:\n",
    "            env (gym.Env): openAI Gym environment\n",
    "            memory_size (int): length of memory\n",
    "            batch_size (int): batch size for sampling\n",
    "            target_update (int): period for target model's hard update\n",
    "            epsilon_decay (float): step size to decrease epsilon\n",
    "            lr (float): learning rate\n",
    "            max_epsilon (float): max value of epsilon\n",
    "            min_epsilon (float): min value of epsilon\n",
    "            gamma (float): discount factor\n",
    "            alpha (float): determines how much prioritization is used\n",
    "            beta (float): determines how much importance sampling is used\n",
    "            prior_eps (float): guarantees every transition can be sampled\n",
    "        \"\"\"\n",
    "        obs_dim = env.observation_space.shape[0]\n",
    "        action_dim = env.action_space.n\n",
    "        \n",
    "        self.env = env\n",
    "        \n",
    "        self.batch_size = batch_size\n",
    "        self.epsilon = max_epsilon\n",
    "        self.epsilon_decay = epsilon_decay\n",
    "        self.seed = seed\n",
    "        self.max_epsilon = max_epsilon\n",
    "        self.min_epsilon = min_epsilon\n",
    "        self.target_update = target_update\n",
    "        self.gamma = gamma\n",
    "        \n",
    "        # device: cpu / gpu\n",
    "        self.device = torch.device(\n",
    "            \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "        )\n",
    "        print(self.device)\n",
    "        \n",
    "        # PER\n",
    "        # In DQN, We used \"ReplayBuffer(obs_dim, memory_size, batch_size)\"\n",
    "        self.beta = beta\n",
    "        self.prior_eps = prior_eps\n",
    "        self.memory = PrioritizedReplayBuffer(\n",
    "            obs_dim, memory_size, batch_size, alpha\n",
    "        )\n",
    "\n",
    "        # networks: dqn, dqn_target\n",
    "        self.dqn = Network(obs_dim, action_dim).to(self.device)\n",
    "        self.dqn_target = Network(obs_dim, action_dim).to(self.device)\n",
    "        self.dqn_target.load_state_dict(self.dqn.state_dict())\n",
    "        self.dqn_target.eval()\n",
    "        \n",
    "        # optimizer\n",
    "        self.optimizer = optim.Adam(self.dqn.parameters())\n",
    "\n",
    "        # transition to store in memory\n",
    "        self.transition = list()\n",
    "        \n",
    "        # mode: train / test\n",
    "        self.is_test = False\n",
    "\n",
    "    def select_action(self, state: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"Select an action from the input state.\"\"\"\n",
    "        # epsilon greedy policy\n",
    "        if self.epsilon > np.random.random():\n",
    "            selected_action = self.env.action_space.sample()\n",
    "        else:\n",
    "            selected_action = self.dqn(\n",
    "                torch.FloatTensor(state).to(self.device)\n",
    "            ).argmax()\n",
    "            selected_action = selected_action.detach().cpu().numpy()\n",
    "        \n",
    "        if not self.is_test:\n",
    "            self.transition = [state, selected_action]\n",
    "        \n",
    "        return selected_action\n",
    "\n",
    "    def step(self, action: np.ndarray) -> Tuple[np.ndarray, np.float64, bool]:\n",
    "        \"\"\"Take an action and return the response of the env.\"\"\"\n",
    "        next_state, reward, terminated, truncated, _ = self.env.step(action)\n",
    "        done = terminated or truncated\n",
    "\n",
    "        if not self.is_test:\n",
    "            self.transition += [reward, next_state, done]\n",
    "            self.memory.store(*self.transition)\n",
    "    \n",
    "        return next_state, reward, done\n",
    "\n",
    "    def update_model(self) -> torch.Tensor:\n",
    "        \"\"\"Update the model by gradient descent.\"\"\"\n",
    "        # PER needs beta to calculate weights\n",
    "        samples = self.memory.sample_batch(self.beta)\n",
    "        weights = torch.FloatTensor(\n",
    "            samples[\"weights\"].reshape(-1, 1)\n",
    "        ).to(self.device)\n",
    "        indices = samples[\"indices\"]\n",
    "\n",
    "        # PER: importance sampling before average\n",
    "        elementwise_loss = self._compute_dqn_loss(samples)\n",
    "        loss = torch.mean(elementwise_loss * weights)\n",
    "\n",
    "        self.optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        self.optimizer.step()\n",
    "        \n",
    "        # PER: update priorities\n",
    "        loss_for_prior = elementwise_loss.detach().cpu().numpy()\n",
    "        new_priorities = loss_for_prior + self.prior_eps\n",
    "        self.memory.update_priorities(indices, new_priorities)\n",
    "\n",
    "        return loss.item()\n",
    "        \n",
    "    def train(self, num_frames: int, plotting_interval: int = 200):\n",
    "        \"\"\"Train the agent.\"\"\"\n",
    "        self.is_test = False\n",
    "        \n",
    "        state, _ = self.env.reset(seed=self.seed)\n",
    "        update_cnt = 0\n",
    "        epsilons = []\n",
    "        losses = []\n",
    "        scores = []\n",
    "        score = 0\n",
    "\n",
    "        for frame_idx in range(1, num_frames + 1):\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "            \n",
    "            # PER: increase beta\n",
    "            fraction = min(frame_idx / num_frames, 1.0)\n",
    "            self.beta = self.beta + fraction * (1.0 - self.beta)\n",
    "\n",
    "            # if episode ends\n",
    "            if done:\n",
    "                state, _ = self.env.reset(seed=self.seed)\n",
    "                scores.append(score)\n",
    "                score = 0\n",
    "\n",
    "            # if training is ready\n",
    "            if len(self.memory) >= self.batch_size:\n",
    "                loss = self.update_model()\n",
    "                losses.append(loss)\n",
    "                update_cnt += 1\n",
    "                \n",
    "                # linearly decrease epsilon\n",
    "                self.epsilon = max(\n",
    "                    self.min_epsilon, self.epsilon - (\n",
    "                        self.max_epsilon - self.min_epsilon\n",
    "                    ) * self.epsilon_decay\n",
    "                )\n",
    "                epsilons.append(self.epsilon)\n",
    "                \n",
    "                # if hard update is needed\n",
    "                if update_cnt % self.target_update == 0:\n",
    "                    self._target_hard_update()\n",
    "\n",
    "            # plotting\n",
    "            if frame_idx % plotting_interval == 0:\n",
    "                self._plot(frame_idx, scores, losses, epsilons)\n",
    "                \n",
    "        self.env.close()\n",
    "                \n",
    "    def test(self, video_folder: str) -> None:\n",
    "        \"\"\"Test the agent.\"\"\"\n",
    "        self.is_test = True\n",
    "        \n",
    "        # for recording a video\n",
    "        naive_env = self.env\n",
    "        self.env = gym.wrappers.RecordVideo(self.env, video_folder=video_folder)\n",
    "        \n",
    "        state, _ = self.env.reset(seed=self.seed)\n",
    "        done = False\n",
    "        score = 0\n",
    "        \n",
    "        while not done:\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "        \n",
    "        print(\"score: \", score)\n",
    "        self.env.close()\n",
    "        \n",
    "        # reset\n",
    "        self.env = naive_env\n",
    "\n",
    "    def _compute_dqn_loss(self, samples: Dict[str, np.ndarray]) -> torch.Tensor:\n",
    "        \"\"\"Return dqn loss.\"\"\"\n",
    "        device = self.device  # for shortening the following lines\n",
    "        state = torch.FloatTensor(samples[\"obs\"]).to(device)\n",
    "        next_state = torch.FloatTensor(samples[\"next_obs\"]).to(device)\n",
    "        action = torch.LongTensor(samples[\"acts\"].reshape(-1, 1)).to(device)\n",
    "        reward = torch.FloatTensor(samples[\"rews\"].reshape(-1, 1)).to(device)\n",
    "        done = torch.FloatTensor(samples[\"done\"].reshape(-1, 1)).to(device)\n",
    "\n",
    "        # G_t   = r + gamma * v(s_{t+1})  if state != Terminal\n",
    "        #       = r                       otherwise\n",
    "        curr_q_value = self.dqn(state).gather(1, action)\n",
    "        next_q_value = self.dqn_target(\n",
    "            next_state\n",
    "        ).max(dim=1, keepdim=True)[0].detach()\n",
    "        mask = 1 - done\n",
    "        target = (reward + self.gamma * next_q_value * mask).to(self.device)\n",
    "\n",
    "        # calculate element-wise dqn loss\n",
    "        elementwise_loss = F.smooth_l1_loss(curr_q_value, target, reduction=\"none\")\n",
    "\n",
    "        return elementwise_loss\n",
    "    \n",
    "    def _target_hard_update(self):\n",
    "        \"\"\"Hard update: target <- local.\"\"\"\n",
    "        self.dqn_target.load_state_dict(self.dqn.state_dict())\n",
    "                \n",
    "    def _plot(\n",
    "        self, \n",
    "        frame_idx: int, \n",
    "        scores: List[float], \n",
    "        losses: List[float], \n",
    "        epsilons: List[float],\n",
    "    ):\n",
    "        \"\"\"Plot the training progresses.\"\"\"\n",
    "        clear_output(True)\n",
    "        plt.figure(figsize=(20, 5))\n",
    "        plt.subplot(131)\n",
    "        plt.title('frame %s. score: %s' % (frame_idx, np.mean(scores[-10:])))\n",
    "        plt.plot(scores)\n",
    "        plt.subplot(132)\n",
    "        plt.title('loss')\n",
    "        plt.plot(losses)\n",
    "        plt.subplot(133)\n",
    "        plt.title('epsilons')\n",
    "        plt.plot(epsilons)\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Environment\n",
    "\n",
    "You can see the [code](https://github.com/Farama-Foundation/Gymnasium/blob/main/gymnasium/envs/classic_control/cartpole.py) and [configurations](https://github.com/Farama-Foundation/Gymnasium/blob/main/gymnasium/envs/classic_control/cartpole.py#L91) of CartPole-v1 from Farama Gymnasium's repository."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# environment\n",
    "env = gym.make(\"CartPole-v1\", max_episode_steps=500, render_mode=\"rgb_array\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set random seed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "seed = 777\n",
    "\n",
    "def seed_torch(seed):\n",
    "    torch.manual_seed(seed)\n",
    "    if torch.backends.cudnn.enabled:\n",
    "        torch.cuda.manual_seed(seed)\n",
    "        torch.backends.cudnn.benchmark = False\n",
    "        torch.backends.cudnn.deterministic = True\n",
    "\n",
    "np.random.seed(seed)\n",
    "random.seed(seed)\n",
    "seed_torch(seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initialize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda\n"
     ]
    }
   ],
   "source": [
    "# parameters\n",
    "num_frames = 100000\n",
    "memory_size = 1000\n",
    "batch_size = 32\n",
    "target_update = 150\n",
    "epsilon_decay = 1 / 2000\n",
    "\n",
    "# train\n",
    "agent = DQNAgent(env, memory_size, batch_size, target_update, epsilon_decay, seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2000x500 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "agent.train(num_frames)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test\n",
    "\n",
    "Run the trained agent (1 episode)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Note: you may need to restart the kernel to use updated packages.\n"
     ]
    }
   ],
   "source": [
    "%pip install -q moviepy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\18745\\miniconda3\\envs\\drl_trade\\lib\\site-packages\\gymnasium\\wrappers\\record_video.py:94: UserWarning: \u001b[33mWARN: Overwriting existing videos at d:\\giteeHub\\custom_dqn_drl\\videos\\per folder (try specifying a different `video_folder` for the `RecordVideo` wrapper if this is not desired)\u001b[0m\n",
      "  logger.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Building video d:\\giteeHub\\custom_dqn_drl\\videos\\per\\rl-video-episode-0.mp4.\n",
      "Moviepy - Writing video d:\\giteeHub\\custom_dqn_drl\\videos\\per\\rl-video-episode-0.mp4\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                               \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Done !\n",
      "Moviepy - video ready d:\\giteeHub\\custom_dqn_drl\\videos\\per\\rl-video-episode-0.mp4\n",
      "score:  500.0\n"
     ]
    }
   ],
   "source": [
    "video_folder=\"videos/per\"\n",
    "agent.test(video_folder=video_folder)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Render"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <video width=\"320\" height=\"240\" alt=\"test\" controls>\n",
       "        <source src=\"data:video/mp4;base64,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\" type=\"video/mp4\"/>\n",
       "        </video>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Played: videos/per\\rl-video-episode-0.mp4\n"
     ]
    }
   ],
   "source": [
    "import base64\n",
    "import glob\n",
    "import io\n",
    "import os\n",
    "\n",
    "from IPython.display import HTML, display\n",
    "\n",
    "\n",
    "def ipython_show_video(path: str) -> None:\n",
    "    \"\"\"Show a video at `path` within IPython Notebook.\"\"\"\n",
    "    if not os.path.isfile(path):\n",
    "        raise NameError(\"Cannot access: {}\".format(path))\n",
    "\n",
    "    video = io.open(path, \"r+b\").read()\n",
    "    encoded = base64.b64encode(video)\n",
    "\n",
    "    display(HTML(\n",
    "        data=\"\"\"\n",
    "        <video width=\"320\" height=\"240\" alt=\"test\" controls>\n",
    "        <source src=\"data:video/mp4;base64,{0}\" type=\"video/mp4\"/>\n",
    "        </video>\n",
    "        \"\"\".format(encoded.decode(\"ascii\"))\n",
    "    ))\n",
    "\n",
    "\n",
    "def show_latest_video(video_folder: str) -> str:\n",
    "    \"\"\"Show the most recently recorded video from video folder.\"\"\"\n",
    "    list_of_files = glob.glob(os.path.join(video_folder, \"*.mp4\"))\n",
    "    latest_file = max(list_of_files, key=os.path.getctime)\n",
    "    ipython_show_video(latest_file)\n",
    "    return latest_file\n",
    "\n",
    "\n",
    "latest_file = show_latest_video(video_folder=video_folder)\n",
    "print(\"Played:\", latest_file)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "dlengine_env",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
